// 版权所有2009 Go作者。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package testing

import (
	"flag"
	"fmt"
	"internal/race"
	"internal/sysinfo"
	"io"
	"math"
	"os"
	"runtime"
	"sort"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"time"
	"unicode"
)

func initBenchmarkFlags() {
	matchBenchmarks = flag.String("test.bench", "", "run only benchmarks matching `regexp`")
	benchmarkMemory = flag.Bool("test.benchmem", false, "print memory allocations for benchmarks")
	flag.Var(&benchTime, "test.benchtime", "run each benchmark for duration `d`")
}

var (
	matchBenchmarks *string
	benchmarkMemory *bool

	benchTime = durationOrCountFlag{d: 1 * time.Second} // 在测试包测试期间更改了
)

type durationOrCountFlag struct {
	d         time.Duration
	n         int
	allowZero bool
}

func (f *durationOrCountFlag) String() string {
	if f.n > 0 {
		return fmt.Sprintf("%dx", f.n)
	}
	return f.d.String()
}

func (f *durationOrCountFlag) Set(s string) error {
	if strings.HasSuffix(s, "x") {
		n, err := strconv.ParseInt(s[:len(s)-1], 10, 0)
		if err != nil || n < 0 || (!f.allowZero && n == 0) {
			return fmt.Errorf("invalid count")
		}
		*f = durationOrCountFlag{n: int(n)}
		return nil
	}
	d, err := time.ParseDuration(s)
	if err != nil || d < 0 || (!f.allowZero && d == 0) {
		return fmt.Errorf("invalid duration")
	}
	*f = durationOrCountFlag{d: d}
	return nil
}

// 全局锁，以确保一次只运行一个基准测试。
var benchmarkLock sync.Mutex

// 用于测量内存的每个基准。
var memStats runtime.MemStats

// InternalBenchmark是一个内部类型，但由于它是跨包的，所以被导出；
// 它是“go test”命令实现的一部分。
type InternalBenchmark struct {
	Name string
	F    func(b *B)
}

// B是传递给基准函数的一种类型，用于管理基准
// 计时并指定要运行的迭代次数。
// 
// 当基准函数返回或调用任何方法
// FailNow、Fatal、Fatalf、SkipNow、Skip或Skipf时，基准结束。这些方法必须仅从运行基准函数的goroutine调用
// 。
// 其他报告方法，如日志和错误的变化，
// 可以从多个goroutine同时调用。
// 
// 和测试一样，基准日志在执行过程中积累，完成后转储到标准输出。与测试不同，基准日志
// 总是打印出来，这样就不会隐藏可能存在影响基准结果的
// 的输出。
type B struct {
	common
	importPath       string // 包含基准的包的导入路径
	context          *benchContext
	N                int
	previousN        int           // 上一次运行的迭代次数
	previousDuration time.Duration // 上一次运行的总持续时间
	benchFunc        func(b *B)
	benchTime        durationOrCountFlag
	bytes            int64
	missingBytes     bool // 其中一个子基准未设置字节。
	timerOn          bool
	showAllocResult  bool
	result           BenchmarkResult
	parallelism      int // RunParallel创建并行性*GOMAXPROCS goroutines 
	// memStats的初始状态。Mallocs和memStats。TotalAlloc。
	startAllocs uint64
	startBytes  uint64
	// 运行后该测试的净总数。
	netAllocs uint64
	netBytes  uint64
	// ReportMetric收集的额外指标。
	extra map[string]float64
}

// StartTimer开始计时测试。该函数在基准测试开始前自动调用
// 但也可用于在
// 调用StopTimer后恢复计时。
func (b *B) StartTimer() {
	if !b.timerOn {
		runtime.ReadMemStats(&memStats)
		b.startAllocs = memStats.Mallocs
		b.startBytes = memStats.TotalAlloc
		b.start = time.Now()
		b.timerOn = true
	}
}

// 停止计时器停止测试计时。这可用于在执行您不想测量的复杂初始化时暂停计时器
// 。
func (b *B) StopTimer() {
	if b.timerOn {
		b.duration += time.Since(b.start)
		runtime.ReadMemStats(&memStats)
		b.netAllocs += memStats.Mallocs - b.startAllocs
		b.netBytes += memStats.TotalAlloc - b.startBytes
		b.timerOn = false
	}
}

// 重置计时器将经过的基准时间和内存分配计数器归零
// 并删除用户报告的度量。
// 它不影响计时器是否正在运行。
func (b *B) ResetTimer() {
	if b.extra == nil {
		// 在读取内存统计数据之前分配额外的映射。
		// 预先调整大小，以避免更多的分配。
		b.extra = make(map[string]float64, 16)
	} else {
		for k := range b.extra {
			delete(b.extra, k)
		}
	}
	if b.timerOn {
		runtime.ReadMemStats(&memStats)
		b.startAllocs = memStats.Mallocs
		b.startBytes = memStats.TotalAlloc
		b.start = time.Now()
	}
	b.duration = 0
	b.netAllocs = 0
	b.netBytes = 0
}

// SetBytes记录单个操作中处理的字节数。
// 如果调用此函数，基准将报告ns/op和MB/s。
func (b *B) SetBytes(n int64) { b.bytes = n }

// ReportAllocs为此基准启用malloc统计。
// 相当于设置-测试。benchmem，但它只影响调用ReportAllocs的
// 基准函数。
func (b *B) ReportAllocs() {
	b.showAllocResult = true
}

// runN以指定的迭代次数运行单个基准测试。
func (b *B) runN(n int) {
	benchmarkLock.Lock()
	defer benchmarkLock.Unlock()
	defer b.runCleanup(normalPanic)
	// 通过清除以前运行中的垃圾，尝试为每次运行获得一个可比较的环境。
	runtime.GC()
	b.raceErrors = -race.Errors()
	b.N = n
	b.parallelism = 1
	b.ResetTimer()
	b.StartTimer()
	b.benchFunc(b)
	b.StopTimer()
	b.previousN = n
	b.previousDuration = b.duration
	b.raceErrors += race.Errors()
	if b.raceErrors > 0 {
		b.Errorf("race detected during execution of benchmark")
	}
}

func min(x, y int64) int64 {
	if x > y {
		return y
	}
	return x
}

func max(x, y int64) int64 {
	if x < y {
		return y
	}
	return x
}

// run1运行benchFunc的第一次迭代。它报告了是否应该运行该基准测试的更多
// 迭代。
func (b *B) run1() bool {
	if ctx := b.context; ctx != nil {
		// 如果需要，扩展maxLen。
		if n := len(b.name) + ctx.extLen + 1; n > ctx.maxLen {
			ctx.maxLen = n + 8 // 增加额外的松弛度，以避免过多的尺寸跳跃。
		}
	}
	go func() {
		// 无论是正常返回还是在FailNow的运行时返回，都表明我们已经完成。戈希特。
		defer func() {
			b.signal <- true
		}()

		b.runN(1)
	}()
	<-b.signal
	if b.failed {
		fmt.Fprintf(b.w, "--- FAIL: %s\n%s", b.name, b.output)
		return false
	}
	// 只有在我们知道不打算继续时才打印输出。
	// 否则将在processBench中打印。
	b.mu.RLock()
	finished := b.finished
	b.mu.RUnlock()
	if atomic.LoadInt32(&b.hasSub) != 0 || finished {
		tag := "BENCH"
		if b.skipped {
			tag = "SKIP"
		}
		if b.chatty != nil && (len(b.output) > 0 || finished) {
			b.trimOutput()
			fmt.Fprintf(b.w, "--- %s: %s\n%s", tag, b.name, b.output)
		}
		return false
	}
	return true
}

var labelsOnce sync.Once

// run在一个单独的goroutine中执行基准测试，包括其所有
// 子基准测试。b不得有次级基准。
func (b *B) run() {
	labelsOnce.Do(func() {
		fmt.Fprintf(b.w, "goos: %s\n", runtime.GOOS)
		fmt.Fprintf(b.w, "goarch: %s\n", runtime.GOARCH)
		if b.importPath != "" {
			fmt.Fprintf(b.w, "pkg: %s\n", b.importPath)
		}
		if cpu := sysinfo.CPU.Name(); cpu != "" {
			fmt.Fprintf(b.w, "cpu: %s\n", cpu)
		}
	})
	if b.context != nil {
		// 运行go测试--测试。替补席
		b.context.processBench(b) // 必须打电话给多本奇。
	} else {
		// 运行func基准测试。
		b.doBench()
	}
}

func (b *B) doBench() BenchmarkResult {
	go b.launch()
	<-b.signal
	return b.result
}

// launch启动基准函数。它会逐渐增加
// 的基准迭代次数，直到基准在请求的基准时间内运行。dubcdefg
// 必须在b上调用run1。
func (b *B) launch() {
	// 无论我们是正常返回
	// 还是通过FailNow的运行时返回，都表明我们已经完成。戈希特。
	defer func() {
		b.signal <- true
	}()

	// 至少在指定的时间内运行基准测试。
	if b.benchTime.n > 0 {
		// 我们已经在run1中运行了一次迭代。
		// 如果请求了-benchtime=1x，则使用该结果。
		// 参见https:
		if b.benchTime.n > 1 {
			b.runN(b.benchTime.n)
		}
	} else {
		d := b.benchTime.d
		for n := int64(1); !b.failed && b.duration < d && n < 1e9; {
			last := n
			// 预测所需的迭代。
			goalns := d.Nanoseconds()
			prevIters := int64(b.N)
			prevns := b.duration.Nanoseconds()
			if prevns <= 0 {
				// 四舍五入，避免被零除掉。
				prevns = 1
			}
			// 操作顺序很重要。
			// 对于非常快的基准测试，prevIters ~=prevns。
			// 如果先除法，得到0或1，
			// 这可以隐藏一个数量级的执行时间。
			// 所以先乘，然后除。
			n = goalns * prevIters / prevns
			// 运行比我们认为需要的更多的迭代（1.2x）。
			n += n / 5
			// 不要增长太快，以免我们之前出现计时错误。
			n = min(n, 100*last)
			// 确保至少比上次多运行一次。
			n = max(n, last+1)
			// 不要运行超过1e9次。（这也使n在32位平台上保持整数范围。）
			n = min(n, 1e9)
			b.runN(int(n))
		}
	}
	b.result = BenchmarkResult{b.N, b.duration, b.bytes, b.netAllocs, b.netBytes, b.extra}
}

// ReportMetric在报告的基准测试结果中添加了“n个单位”。
// 如果度量是每次迭代，则调用者应除以b.N，
// 并且按约定单位应以“/op”结尾。
// ReportMetric覆盖同一单位以前报告的任何值。
// 如果unit是空字符串，或者如果unit包含
// 任何空格，则ReportMetric会出现恐慌。
// 如果unit是通常由基准框架本身报告的单元
// （例如“allocs/op”），ReportMetric将覆盖该度量。
// 将“ns/op”设置为0将抑制该内置度量。
func (b *B) ReportMetric(n float64, unit string) {
	if unit == "" {
		panic("metric unit must not be empty")
	}
	if strings.IndexFunc(unit, unicode.IsSpace) >= 0 {
		panic("metric unit must not contain whitespace")
	}
	b.extra[unit] = n
}

// 基准测试结果包含基准测试运行的结果。
type BenchmarkResult struct {
	N         int           // 迭代次数。
	T         time.Duration // 所用的总时间。
	Bytes     int64         // 在一次迭代中处理的字节数。
	MemAllocs uint64        // 内存分配的总数。
	MemBytes  uint64        // 分配的总字节数。

	// 额外记录ReportMetric报告的其他指标。
	Extra map[string]float64
}

// NsPerOp返回“ns/op”度量。
func (r BenchmarkResult) NsPerOp() int64 {
	if v, ok := r.Extra["ns/op"]; ok {
		return int64(v)
	}
	if r.N <= 0 {
		return 0
	}
	return r.T.Nanoseconds() / int64(r.N)
}

// mbPerSec返回“MB/s”指标。
func (r BenchmarkResult) mbPerSec() float64 {
	if v, ok := r.Extra["MB/s"]; ok {
		return v
	}
	if r.Bytes <= 0 || r.T <= 0 || r.N <= 0 {
		return 0
	}
	return (float64(r.Bytes) * float64(r.N) / 1e6) / r.T.Seconds()
}

// AllocPerop返回“allocs/op”度量，
// 计算为r.MemAllocs/r.N。
func (r BenchmarkResult) AllocsPerOp() int64 {
	if v, ok := r.Extra["allocs/op"]; ok {
		return int64(v)
	}
	if r.N <= 0 {
		return 0
	}
	return int64(r.MemAllocs) / int64(r.N)
}

// AllocedBytesPerOp返回“B/op”度量，
// 计算为r.MemBytes/r.N。
func (r BenchmarkResult) AllocedBytesPerOp() int64 {
	if v, ok := r.Extra["B/op"]; ok {
		return int64(v)
	}
	if r.N <= 0 {
		return 0
	}
	return int64(r.MemBytes) / int64(r.N)
}

// 字符串返回基准测试结果的摘要。
// 它遵循
// golang.org/design/14313-benchmark-format，不包括
// 基准名称。
// 额外指标覆盖相同名称的内置指标。
// String不包括allocs/op或B/op，因为它们是由MemString报告的。
func (r BenchmarkResult) String() string {
	buf := new(strings.Builder)
	fmt.Fprintf(buf, "%8d", r.N)

	// 以浮点形式获取ns/op。
	ns, ok := r.Extra["ns/op"]
	if !ok {
		ns = float64(r.T.Nanoseconds()) / float64(r.N)
	}
	if ns != 0 {
		buf.WriteByte('\t')
		prettyPrint(buf, ns, "ns/op")
	}

	if mbs := r.mbPerSec(); mbs != 0 {
		fmt.Fprintf(buf, "\t%7.2f MB/s", mbs)
	}

	// 打印标准
	// 度量中未表示的额外度量。
	var extraKeys []string
	for k := range r.Extra {
		switch k {
		case "ns/op", "MB/s", "B/op", "allocs/op":
			// 其他地方报告的内置指标。
			continue
		}
		extraKeys = append(extraKeys, k)
	}
	sort.Strings(extraKeys)
	for _, k := range extraKeys {
		buf.WriteByte('\t')
		prettyPrint(buf, r.Extra[k], k)
	}
	return buf.String()
}

func prettyPrint(w io.Writer, x float64, unit string) {
	// 打印小数点前10位的所有数字
	// 打印带有四个sig的小数字。字段宽度为
	// 选择以使整个部分在10位中匹配，同时对齐
	// 所有小数格式的小数点。
	var format string
	switch y := math.Abs(x); {
	case y == 0 || y >= 999.95:
		format = "%10.0f %s"
	case y >= 99.995:
		format = "%12.1f %s"
	case y >= 9.9995:
		format = "%13.2f %s"
	case y >= 0.99995:
		format = "%14.3f %s"
	case y >= 0.099995:
		format = "%15.4f %s"
	case y >= 0.0099995:
		format = "%16.5f %s"
	case y >= 0.00099995:
		format = "%17.6f %s"
	default:
		format = "%18.7f %s"
	}
	fmt.Fprintf(w, format, x, unit)
}

// MemString以与“go test”相同的格式返回r.AllowedBytesPerop和r.AllocPerop。
func (r BenchmarkResult) MemString() string {
	return fmt.Sprintf("%8d B/op\t%8d allocs/op",
		r.AllocedBytesPerOp(), r.AllocsPerOp())
}

// benchmarkName返回基准的全名，包括procs后缀。
func benchmarkName(name string, n int) string {
	if n != 1 {
		return fmt.Sprintf("%s-%d", name, n)
	}
	return name
}

type benchContext struct {
	match *matcher

	maxLen int // 记录在案的最大基准名称。
	extLen int // 最大延长长度。
}

// RunBenchmarks是一个内部函数，但由于是跨包的，所以被导出；
// 它是“go test”命令实现的一部分。
func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark) {
	runBenchmarks("", matchString, benchmarks)
}

func runBenchmarks(importPath string, matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark) bool {
	// 如果没有指定标志，则不要运行基准测试。
	if len(*matchBenchmarks) == 0 {
		return true
	}
	// 收集匹配的基准并确定最长的名称。
	maxprocs := 1
	for _, procs := range cpuList {
		if procs > maxprocs {
			maxprocs = procs
		}
	}
	ctx := &benchContext{
		match:  newMatcher(matchString, *matchBenchmarks, "-test.bench"),
		extLen: len(benchmarkName("", maxprocs)),
	}
	var bs []InternalBenchmark
	for _, Benchmark := range benchmarks {
		if _, matched, _ := ctx.match.fullName(nil, Benchmark.Name); matched {
			bs = append(bs, Benchmark)
			benchName := benchmarkName(Benchmark.Name, maxprocs)
			if l := len(benchName) + ctx.extLen + 1; l > ctx.maxLen {
				ctx.maxLen = l
			}
		}
	}
	main := &B{
		common: common{
			name:  "Main",
			w:     os.Stdout,
			bench: true,
		},
		importPath: importPath,
		benchFunc: func(b *B) {
			for _, Benchmark := range bs {
				b.Run(Benchmark.Name, Benchmark.F)
			}
		},
		benchTime: benchTime,
		context:   ctx,
	}
	if Verbose() {
		main.chatty = newChattyPrinter(main.w)
	}
	main.runN(1)
	return !main.failed
}

// processBench为配置的CPU计数运行工作台b并打印结果。
func (ctx *benchContext) processBench(b *B) {
	for i, procs := range cpuList {
		for j := uint(0); j < *count; j++ {
			runtime.GOMAXPROCS(procs)
			benchName := benchmarkName(b.name, procs)

			// 如果是聊天，我们已经打印了这些信息。
			if b.chatty == nil {
				fmt.Fprintf(b.w, "%-*s\t", ctx.maxLen, benchName)
			}
			// 重新计算除第一次迭代之外的所有迭代的运行时间。
			if i > 0 || j > 0 {
				b = &B{
					common: common{
						signal: make(chan bool),
						name:   b.name,
						w:      b.w,
						chatty: b.chatty,
						bench:  true,
					},
					benchFunc: b.benchFunc,
					benchTime: b.benchTime,
				}
				b.run1()
			}
			r := b.doBench()
			if b.failed {
				// 这里的输出可能很长，但可能不是。无论如何，我们都会打印出来，因为我们不想删减基准测试失败的原因。
				fmt.Fprintf(b.w, "--- FAIL: %s\n%s", benchName, b.output)
				continue
			}
			results := r.String()
			if b.chatty != nil {
				fmt.Fprintf(b.w, "%-*s\t", ctx.maxLen, benchName)
			}
			if *benchmarkMemory || b.showAllocResult {
				results += "\t" + r.MemString()
			}
			fmt.Fprintln(b.w, results)
			// 与测试不同，我们忽略了-chatty标志，总是为
			// 基准打印输出，因为输出生成时间会扭曲结果。
			if len(b.output) > 0 {
				b.trimOutput()
				fmt.Fprintf(b.w, "--- BENCH: %s\n%s", benchName, b.output)
			}
			if p := runtime.GOMAXPROCS(-1); p != procs {
				fmt.Fprintf(os.Stderr, "testing: %s left GOMAXPROCS set to %d\n", benchName, p)
			}
		}
	}
}

// 将基准f作为具有给定名称的子基准运行。它报告
// 是否有任何故障。
// 
// 子基准与任何其他基准相同。调用Run at 
// 至少一次的基准测试本身不会被测量，只会在N=1时被调用一次。
func (b *B) Run(name string, f func(b *B)) bool {
	// 由于b有子基准，我们将不再将其作为基准运行。
	// 释放锁并在退出时获取，以确保锁保持成对。
	atomic.StoreInt32(&b.hasSub, 1)
	benchmarkLock.Unlock()
	defer benchmarkLock.Lock()

	benchName, ok, partial := b.name, true, false
	if b.context != nil {
		benchName, ok, partial = b.context.match.fullName(&b.common, name)
	}
	if !ok {
		return true
	}
	var pc [maxStackLen]uintptr
	n := runtime.Callers(2, pc[:])
	sub := &B{
		common: common{
			signal:  make(chan bool),
			name:    benchName,
			parent:  &b.common,
			level:   b.level + 1,
			creator: pc[:n],
			w:       b.w,
			chatty:  b.chatty,
			bench:   true,
		},
		importPath: b.importPath,
		benchFunc:  f,
		benchTime:  b.benchTime,
		context:    b.context,
	}
	if partial {
		// 部分名称匹配，比如-bench=X/Y匹配BenchmarkX。
		// 仅处理次级基准（如果有）。
		atomic.StoreInt32(&sub.hasSub, 1)
	}

	if b.chatty != nil {
		labelsOnce.Do(func() {
			fmt.Printf("goos: %s\n", runtime.GOOS)
			fmt.Printf("goarch: %s\n", runtime.GOARCH)
			if b.importPath != "" {
				fmt.Printf("pkg: %s\n", b.importPath)
			}
			if cpu := sysinfo.CPU.Name(); cpu != "" {
				fmt.Printf("cpu: %s\n", cpu)
			}
		})

		fmt.Println(benchName)
	}

	if sub.run1() {
		sub.run()
	}
	b.add(sub.result)
	return !sub.failed
}

// add在一次迭代中按顺序模拟运行的基准测试。
// 用于在
// 与Run组合中使用func基准测试时，给出一些有意义的结果。
func (b *B) add(other BenchmarkResult) {
	r := &b.result
	// 聚合的基准测试结果类似于在单个基准测试中按顺序运行所有子基准测试。
	r.N = 1
	r.T += time.Duration(other.NsPerOp())
	if other.Bytes == 0 {
		// 如果不是所有的子基准，那么对字节进行求和将毫无意义。
		b.missingBytes = true
		r.Bytes = 0
	}
	if !b.missingBytes {
		r.Bytes += other.Bytes
	}
	r.MemAllocs += uint64(other.AllocsPerOp())
	r.MemBytes += uint64(other.AllocedBytesPerOp())
}

// trimOutput缩短了基准测试的输出，基准测试可能很长。
func (b *B) trimOutput() {
	// 输出可能会出现多次，因为基准
	// 运行了多次，但至少会看到它。这没什么大不了的
	// 因为基准很少打印，但为了以防万一，如果太长的话，我们会修剪它。
	const maxNewlines = 10
	for nlCount, j := 0, 0; j < len(b.output); j++ {
		if b.output[j] == '\n' {
			nlCount++
			if nlCount >= maxNewlines {
				b.output = append(b.output[:j], "\n\t... [output truncated]\n"...)
				break
			}
		}
	}
}

// RunParallel使用PB来运行并行基准测试。
type PB struct {
	globalN *uint64 // 在所有工作进程间共享迭代计数器
	grain   uint64  // 一次从全局获取那么多迭代
	cache   uint64  // 获取的迭代的本地缓存
	bN      uint64  // 要执行的迭代总数（b.N）
}

// 下一步报告是否有更多的迭代要执行。
func (pb *PB) Next() bool {
	if pb.cache == 0 {
		n := atomic.AddUint64(pb.globalN, pb.grain)
		if n <= pb.bN {
			pb.cache = pb.grain
		} else if n < pb.bN+pb.grain {
			pb.cache = pb.bN + pb.grain - n
		} else {
			return false
		}
	}
	pb.cache--
	return true
}

// RunParallel并行运行基准测试。
// 它创建多个goroutine，并在其中分配b.N迭代。
// goroutine的数量默认为GOMAXPROCS。要增加
// 非CPU绑定基准的并行性，请在RunParallel之前调用SetParallelism。
// RunParallel通常与go test-cpu标志一起使用。
// 
// body函数将在每个goroutine中运行。它应该设置任何
// goroutine local state，然后迭代到pb。接下来返回false。
// 不应使用StartTimer、StopTimer或ResetTimer函数，因为它们具有全局效应。它也不应该叫Run。
func (b *B) RunParallel(body func(*PB)) {
	if b.N == 0 {
		return // 探测时无需操作。
	}
	// 将粒度计算为需要约100µs的迭代次数。
	// 100µs足以摊销开销并提供足够的
	// 动态负载平衡。
	grain := uint64(0)
	if b.previousN > 0 && b.previousDuration > 0 {
		grain = 1e5 * uint64(b.previousN) / uint64(b.previousDuration)
	}
	if grain < 1 {
		grain = 1
	}
	// 我们预计内部循环和函数调用至少需要10ns，
	// 所以不要进行超过100µs/10ns=1e4次迭代。
	if grain > 1e4 {
		grain = 1e4
	}

	n := uint64(0)
	numProcs := b.parallelism * runtime.GOMAXPROCS(0)
	var wg sync.WaitGroup
	wg.Add(numProcs)
	for p := 0; p < numProcs; p++ {
		go func() {
			defer wg.Done()
			pb := &PB{
				globalN: &n,
				grain:   grain,
				bN:      uint64(b.N),
			}
			body(pb)
		}()
	}
	wg.Wait()
	if n <= uint64(b.N) && !b.Failed() {
		b.Fatal("RunParallel: body exited without pb.Next() == false")
	}
}

// SetParallelism设置RunParallel与p*GOMAXPROCS使用的GoRoutine数。
// 对于CPU绑定的基准测试，通常不需要调用SetParallelism。
// 如果p小于1，此调用将无效。
func (b *B) SetParallelism(p int) {
	if p >= 1 {
		b.parallelism = p
	}
}

// 基准测试单个函数。它对于创建
// 不使用“go test”命令的自定义基准测试非常有用。
// 
// 如果f依赖于测试标志，则必须使用Init在调用基准测试和调用标志之前注册这些标志。作语法分析
// 
// 如果f调用Run，结果将是运行其所有
// 在单个基准中不按顺序调用Run的子基准的估计值。
func Benchmark(f func(b *B)) BenchmarkResult {
	b := &B{
		common: common{
			signal: make(chan bool),
			w:      discard{},
		},
		benchFunc: f,
		benchTime: benchTime,
	}
	if b.run1() {
		b.run()
	}
	return b.result
}

type discard struct{}

func (discard) Write(b []byte) (n int, err error) { return len(b), nil }
